home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2003 November A / PCWK1103A.iso / ABBYY FineReader 7.0 PRO / data1.cab / pdf_draw.ps < prev    next >
Text File  |  2002-02-23  |  35KB  |  1,151 lines
  1. %    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: pdf_draw.ps,v 1.36.2.1 2002/02/22 19:45:55 ray Exp $
  17. % pdf_draw.ps
  18. % PDF drawing operations (graphics, text, and images).
  19.  
  20. /.setlanguagelevel where { pop 2 .setlanguagelevel } if
  21. .currentglobal true .setglobal
  22. /pdfdict where { pop } { /pdfdict 100 dict def } ifelse
  23. GS_PDF_ProcSet begin
  24. pdfdict begin
  25.  
  26. % For simplicity, we use a single interpretation dictionary for all
  27. % PDF graphics operations, even though this is too liberal.
  28. /drawopdict 100 dict def
  29.  
  30. % ================================ Graphics ================================ %
  31.  
  32. % ---------------- Functions ---------------- %
  33.  
  34. % Note that resolvefunction converts a PDF Function to a PostScript Function;
  35. % resolve*fnproc converts a PDF function to a PostScript procedure.
  36.  
  37. /fnrdict mark
  38.   0 { .resolvefn0 }
  39.   2 { }
  40.   3 { .resolvefn3 }
  41.   4 { .resolvefn4 }
  42. .dicttomark readonly def
  43.  
  44. /.resolvefn0 {
  45.         % Don't lose our place in PDFfile.
  46.   PDFfile fileposition exch
  47.   dup true resolvestream
  48.         % The stream isn't positionable, so read all the data now.
  49.         % Stack: filepos fndict stream
  50.   1 index /Range oget length 2 idiv 2 index /BitsPerSample oget mul
  51.   2 index /Size oget { mul } forall
  52.   7 add 8 idiv string
  53.   1 index exch readstring pop exch closefile
  54.         % Stack: filepos fndict data
  55.   exch dup length 1 add dict .copydict
  56.   dup /DataSource 4 -1 roll put
  57.   exch PDFfile exch setfileposition
  58. } bdef
  59.  
  60. /.resolvefn3 {
  61.   dup length dict .copydict
  62.   dup /Bounds 2 copy knownoget { put } { pop pop } ifelse
  63.   dup /Encode 2 copy knownoget { put } { pop pop } ifelse
  64.   dup /Functions 2 copy oget mark exch dup {
  65.     oforce .resolvefn
  66.   } forall
  67.   counttomark -1 roll astore exch pop put
  68. } bdef
  69.  
  70. /.resolvefn4 {
  71.   PDFfile fileposition exch             % filepos fndict
  72.   dup true resolvestream                % filepos fndict stream
  73.   exch dup length dict copy             % filepos stream fndict2
  74.   dup /Function undef                   % filepos stream fndict2
  75.   exch dup token not {
  76.     () /rangecheck cvx signalerror
  77.   } if
  78.   exch token {
  79.     /rangecheck cvx signalerror
  80.   } if
  81.         % Use .bind to avoid idiom recognition.
  82.   .bind
  83.   1 index /Function 3 -1 roll put
  84.   exch PDFfile exch setfileposition
  85. } bdef
  86. currentdict /tfopdict undef
  87.  
  88. /.resolvefn {        % <fndict> .resolvefn <fndict'>
  89.   dup /FunctionType oget //fnrdict exch get exec
  90. } bdef
  91.  
  92. /resolvefunction {    % <fndict> resolvefunction <function>
  93.   .resolvefn
  94.   DEBUG { (%Function: ) print dup === flush } if
  95. } bdef
  96.  
  97. /resolvefnproc {    % <fndict> resolvefnproc <proc>
  98.   resolvefunction .buildfunction
  99. } bdef
  100.  
  101. /resolveidfnproc {    % <fndict> resolveidfnproc <proc>
  102.   dup /Identity eq { pop { } } { resolvefnproc } ifelse
  103. } bdef
  104.  
  105. /resolvedefaultfnproc {    % <fndict> <default> resolved'fnproc <proc>
  106.   1 index /Default eq { exch pop } { pop resolveidfnproc } ifelse
  107. } bdef
  108.  
  109. % ---------------- Shadings ---------------- %
  110.  
  111. /shrdict mark
  112.   /ColorSpace {
  113.     resolvecolorspace
  114.   }
  115.   /Function {
  116.     dup type /dicttype eq {
  117.       resolvefunction
  118.     } {
  119.       [ exch { oforce resolvefunction } forall ]
  120.     } ifelse
  121.   }
  122. .dicttomark readonly def
  123.  
  124. /resolveshading {    % <shadingstream> resolveshading <shading>
  125.   PDFfile fileposition exch
  126.   mark exch {
  127.     oforce //shrdict 2 index .knownget { exec } if
  128.   } forall .dicttomark
  129.   dup /ShadingType get 4 ge {
  130.     dup dup true resolvestream
  131.         % Make a reusable stream so that the shading doesn't
  132.         % reposition PDFfile at unexpected times.
  133.     /ReusableStreamDecode filter /DataSource exch put
  134.   } if exch PDFfile exch setfileposition
  135. } bdef
  136. /resolvesh {        % <shname> resolveshading <shading>
  137.   Page /Shading rget {
  138.     resolveshading
  139.   } {
  140.     null
  141.   }ifelse
  142. } bdef
  143.  
  144. % ---------------- Halftones ---------------- %
  145.  
  146. /spotfunctions mark
  147.   /Round {
  148.     abs exch abs 2 copy add 1 le {
  149.       dup mul exch dup mul add 1 exch sub 
  150.     } {
  151.       1 sub dup mul exch 1 sub dup mul add 1 sub
  152.     } ifelse
  153.   }
  154.   /Diamond {
  155.     abs exch abs 2 copy add .75 le {
  156.       dup mul exch dup mul add 1 exch sub
  157.     } {
  158.       2 copy add 1.23 le {
  159.     .85 mul add 1 exch sub
  160.       } {
  161.     1 sub dup mul exch 1 sub dup mul add 1 sub
  162.       } ifelse
  163.     } ifelse
  164.   }
  165.   /Ellipse {
  166.     abs exch abs 2 copy 3 mul exch 4 mul add 3 sub dup 0 lt {
  167.       pop dup mul exch .75 div dup mul add 4 div 1 exch sub
  168.     } {
  169.       dup 1 gt {
  170.     pop 1 exch sub dup mul exch 1 exch sub
  171.     .75 div dup mul add 4 div 1 sub
  172.       } {
  173.     .5 exch sub exch pop exch pop
  174.       } ifelse
  175.     } ifelse
  176.   }
  177.   /EllipseA { dup mul .9 mul exch dup mul add 1 exch sub }
  178.   /InvertedEllipseA { dup mul .9 mul exch dup mul add 1 sub }
  179.   /EllipseB { dup 5 mul 8 div mul exch dup mul exch add sqrt 1 exch sub }
  180.   /EllipseC { dup mul .9 mul exch dup mul add 1 exch sub }
  181.   /InvertedEllipseC { dup mul .9 mul exch dup mul add 1 sub }
  182.   /Line { exch pop abs neg }
  183.   /LineX { pop }
  184.   /LineY { exch pop }
  185.   /Square { abs exch abs 2 copy lt { exch } if pop neg }
  186.   /Cross { abs exch abs 2 copy gt { exch } if pop neg }
  187.   /Rhomboid { abs exch abs 0.9 mul add 2 div }
  188.   /DoubleDot { 2 {360 mul sin 2 div exch } repeat add }
  189.   /InvertedDoubleDot { 2 {360 mul sin 2 div exch } repeat add neg }
  190.   /SimpleDot { dup mul exch dup mul add 1 exch sub }
  191.   /InvertedSimpleDot { dup mul exch dup mul add 1 sub }
  192.   /CosineDot { 180 mul cos exch 180 mul cos add 2 div }
  193.   /Double { exch 2 div exch 2 { 360 mul sin 2 div exch } repeat add }
  194.   /InvertedDouble {
  195.     exch 2 div exch 2 { 360 mul sin 2 div exch } repeat add neg
  196.   }
  197. .dicttomark readonly def
  198.  
  199. /htrdict mark
  200.   1 { .resolveht1 }
  201.   5 { .resolveht5 }
  202.     % We don't support types 6, 10, or 16 yet.
  203. .dicttomark readonly def
  204.  
  205. /.resolveht1 {
  206.   mark exch {
  207.     oforce
  208.     1 index /SpotFunction eq {
  209.       dup type /nametype eq
  210.     { //spotfunctions exch get } { resolvefnproc }
  211.       ifelse
  212.     } {
  213.       1 index /TransferFunction eq {
  214.     resolveidfnproc
  215.       } if
  216.     } ifelse
  217.   } forall .dicttomark
  218. } bdef
  219.  
  220. /.resolveht5 {
  221.   mark exch {
  222.     oforce dup type /dicttype eq { resolvehalftone } if
  223.   } forall .dicttomark
  224. } bdef
  225.  
  226. /resolvehalftone {    % <dict> resolvehalftone <halftone>
  227.   dup /HalftoneType get //htrdict exch get exec
  228. } bdef
  229.  
  230. % ---------------- Graphics state management ---------------- %
  231.  
  232. /cmmatrix matrix def
  233. drawopdict begin
  234.             % Graphics state stack
  235.   /q { q } def
  236.   /Q { Q } def
  237.             % Graphics state setting
  238.   /cm { //cmmatrix astore concat } def
  239.   /i /setflat load def
  240.   /J /setlinecap load def
  241.   /d /setdash load def
  242.   /j /setlinejoin load def
  243.   /w /setlinewidth load def
  244.   /M /setmiterlimit load def
  245.   /gs { gs } def
  246. end
  247.  
  248. % Each entry in this dictionary is
  249. %    <gsres> <value> -proc- <gsres>
  250. /gsbg {
  251.   /BGDefault load resolvedefaultfnproc setblackgeneration
  252. } bdef
  253. /gsucr {
  254.   /UCRDefault load resolvedefaultfnproc setundercolorremoval
  255. } bdef
  256. /gstr {
  257.   dup type /arraytype eq {
  258.     { oforce /TRDefault load resolvedefaultfnproc } forall
  259.     setcolortransfer
  260.   } {
  261.     /TRDefault load resolvedefaultfnproc settransfer
  262.   } ifelse
  263. } bdef
  264. /gsparamdict mark
  265.   /SA { setstrokeadjust }
  266.   /OP { 1 index /op known not { dup op } if OP }
  267.     % The PDF 1.3 specification says that the name /Default is only
  268.     % recognized for {BG,UCR,TR}2.  However, PDF 1.3 files produced
  269.     % by Adobe Acrobat Distiller 4.0 for Windows use the name /Default
  270.     % with the older keys, so we have to implement this.
  271.   /BG { 1 index /BG2 known { pop } { gsbg } ifelse }
  272.   /UCR { 1 index /UCR2 known { pop } { gsucr } ifelse }
  273.   /TR { 1 index /TR2 known { pop } { gstr } ifelse }
  274.   /HT {
  275.     dup /Default eq {
  276.       pop .setdefaultscreen
  277.     } {
  278.     %****** DOESN'T IMPLEMENT THE STREAM CASE YET ******
  279.       resolvehalftone sethalftone
  280.     } ifelse
  281.   }
  282.   /HTP {
  283.     % HTP may be present even if this isn't a DPS interpreter.
  284.     /sethalftonephase where { pop aload pop sethalftonephase } { pop } ifelse
  285.   }
  286.     % PDF 1.3
  287.   /Font { aload pop Tf }
  288.   /LW { setlinewidth }
  289.   /LC { setlinecap }
  290.   /LJ { setlinejoin }
  291.   /ML { setmiterlimit }
  292.   /D { aload pop setdash }
  293.   /RI { ri }
  294.   /op { op }
  295.   /OPM { OPM }
  296.   /BG2 { gsbg }
  297.   /UCR2 { gsucr }
  298.   /TR2 { gstr }
  299.   /FL { setflat }
  300.   /SM {
  301.     % SM may be present even if this is only a Level 2 interpreter.
  302.     /setsmoothness where { pop setsmoothness } { pop } ifelse
  303.   }
  304.     % PDF 1.4
  305.     % All of these require the "transparency" feature in the interpreter.
  306.   /ca { ca }
  307.   /CA { CA }
  308.   /SMask { gssmask }
  309.   /AIS { AIS }
  310.   /BM { BM }
  311.   /TK { TK }
  312. .dicttomark readonly def
  313. /gs {            % <gsres> gs -
  314.   Page /ExtGState rget {
  315.     % We keep the dictionary on the stack during the forall so that
  316.     % keys that interact with each other have access to it.
  317.     dup {
  318.       oforce exch gsparamdict exch .knownget { exec } { pop } ifelse
  319.     } forall pop
  320.   } if
  321. } bdef
  322.  
  323. % ------ Transparency support ------ %
  324.  
  325. /gssmask {
  326.   dup /None eq {
  327.     pop null
  328.   } {
  329.     % Preprocess the SMask value into a parameter dictionary for
  330.     % .begintransparencymask, with added /BBox and /Draw keys.
  331.     mark exch        % Stack: mark smaskdict
  332.     dup /S oget /Subtype exch 3 2 roll
  333.             % Stack: mark ... smaskdict
  334.     dup /BC knownoget { /Background exch 3 2 roll } if
  335.     dup /TR knownoget {
  336.       resolveidfnproc /TransferFunction exch 3 2 roll
  337.     } if    
  338.     dup /G oget dup /BBox oget /BBox exch 4 2 roll
  339.     /.execmaskgroup cvx 2 packedarray cvx /Draw exch 3 2 roll
  340.     pop .dicttomark
  341.   } ifelse SMask
  342. } bdef
  343.  
  344. % This procedure is called to actually render the soft mask.
  345. /.execmaskgroup {    % <masknum> <paramdict> <formdict> .execmaskgroup -
  346.     % Save our place in PDFfile, and do a gsave to avoid resetting
  347.     % the color space.
  348.   gsave PDFfile fileposition 4 1 roll
  349.     % We have to select the group's color space so that the
  350.     % background color will be interpreted correctly.
  351.   dup /Group oget /CS knownoget { csresolve setcolorspace } if
  352.   exch dup /BBox get aload pop .begintransparencymask {
  353.     dup /Resources knownoget { oforce } { 0 dict } ifelse
  354.     exch false resolvestream
  355.     .execgroup .endtransparencymask
  356.   } .internalstopped {
  357.     .discardtransparencymask stop
  358.   } if
  359.   PDFfile exch setfileposition grestore
  360. } bdef
  361. % Paint a Form+Group XObject, either for a transparency mask or for a Do.
  362. /.execgroup {        % <resdict> <stream> .execgroup -
  363.   gsave
  364.   1 .setopacityalpha 1 .setshapealpha
  365.   0 .inittransparencymask 1 .inittransparencymask
  366.   /Compatible .setblendmode
  367.     % Execute the body of the Form, similar to DoForm.
  368.   pdfopdict .pdfruncontext
  369.   grestore
  370. } bdef
  371.  
  372. /.beginformgroup {    % groupdict bbox .beginformgroup -
  373.   exch mark exch            % bbox mark groupdict
  374.   dup /CS knownoget { csresolve setcolorspace } if
  375.   dup /I knownoget { /Isolated exch 3 2 roll } if
  376.   dup /K knownoget { /Knockout exch 3 2 roll } if
  377.   pop .dicttomark
  378.         % Stack: bbox paramdict
  379.   exch aload pop
  380.   .begintransparencygroup
  381. } bdef
  382.  
  383. % .paintgroupform implements the Form PaintProc in the case where the
  384. % Form XObject dictionary includes a Group key.  See .paintform below.
  385. /.paintgroupform {    % <resdict> <stream> <formdict> .paintgroupform -
  386.   dup /Group oget exch /BBox oget
  387.         % Stack: resdict stream groupdict bbox
  388.   .beginformgroup {
  389.     .execgroup
  390.   } .internalstopped {
  391.     .discardtransparencygroup stop
  392.   } if .endtransparencygroup
  393. } bdef
  394.  
  395. % Make an ImageType 103 (soft-masked) image.
  396. /makesoftmaskimage {    % <datasource> <imagemask> <SMask> makesoftmaskimage
  397.             %   <datasource> <imagemask>, updates currentdict =
  398.             %   imagedict
  399.         % See the ImageType 3 case of makemaskimage below.
  400.         % SMask is a stream, another Image XObject.
  401.         % Stack: datasource imagemask(false) smaskstreamdict
  402.   PDFfile fileposition exch
  403.   dup /Matte knownoget { /Matte exch def } if
  404.   dup length dict makeimagedict pop
  405.         % In order to prevent the two data sources from being
  406.         % aliased, we need to make at least one a reusable stream.
  407.         % We pick the mask, since it's smaller (in case we need to
  408.         % read all its data now).
  409.         % Stack: datasource imagemask(false) savedpos
  410.         % maskdict is currentdict
  411.   /DataSource DataSource mark
  412.     /Intent 1
  413.     /AsyncRead true
  414.   .dicttomark .reusablestreamdecode def
  415.   PDFfile exch setfileposition
  416.   currentdict end currentdict end
  417.   5 dict begin
  418.   /ImageType 103 def
  419.   /DataDict exch def
  420.   dup /InterleaveType 3 put
  421.   DataDict /Matte .knownget {
  422.     /Matte exch def
  423.   } if
  424.   AlphaIsShape { /ShapeMaskDict } { /OpacityMaskDict } ifelse exch def
  425.   /ColorSpace DataDict /ColorSpace get def
  426. } bdef
  427.  
  428. % ---------------- Color setting ---------------- %
  429.  
  430. /01_1 [0 1] readonly def
  431. /01_3 [0 1 0 1 0 1] readonly def
  432. /01_4 [0 1 0 1 0 1 0 1] readonly def
  433.  
  434. % The keys here are resolved (PostScript, not PDF) color space names.
  435. /csncompdict mark
  436.   /DeviceGray { pop 1 }
  437.   /DeviceRGB { pop 3 }
  438.   /DeviceCMYK { pop 4 }
  439.   /CIEBasedA { pop 1 }
  440.   /CIEBasedABC { pop 3 }
  441.   /ICCBased { 1 oget /N oget }
  442.   /Separation { pop 1 }
  443.   /DeviceN { 1 oget length }
  444. .dicttomark readonly def
  445.  
  446. % Perhaps some of the values in the following need to be modified
  447. % depending on the WhitePoint value....
  448. /cslabinit mark
  449.   /DecodeABC [{16 add 116 div} bind {500 div} bind {200 div} bind]
  450.   /MatrixABC [1 1 1 1 0 0 0 0 -1]
  451.   /DecodeLMN [
  452.     {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse
  453.      0.9505 mul} bind
  454.     {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse
  455.      } bind
  456.     {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse
  457.      1.0890 mul} bind
  458.   ]
  459. .dicttomark readonly def
  460.  
  461. /csrdict mark
  462.   /DeviceGray {
  463.     /DefaultGray Page /ColorSpace rget { exch pop resolvecolorspace } if
  464.   }
  465.   /DeviceRGB {
  466.     /DefaultRGB Page /ColorSpace rget { exch pop resolvecolorspace } if
  467.   }
  468.   /DeviceCMYK { }
  469.   /CalGray {
  470.     1 oget 6 dict begin
  471.     dup /Gamma knownoget {
  472.       /exp load 2 packedarray cvx /DecodeA exch def
  473.     } if
  474.     dup /BlackPoint knownoget { /BlackPoint exch def } if
  475.     dup /WhitePoint knownoget { /WhitePoint exch def } if
  476.     pop [ /CIEBasedA currentdict end ]
  477.   }
  478.   /CalRGB {
  479.     1 oget 6 dict begin
  480.     dup /Gamma knownoget {
  481.       [ exch { /exp load 2 packedarray cvx } forall
  482.       ] /DecodeABC exch def
  483.     } if
  484.     dup /Matrix knownoget { /MatrixABC exch def } if
  485.     dup /BlackPoint knownoget { /BlackPoint exch def } if
  486.     dup /WhitePoint knownoget { /WhitePoint exch def } if
  487.     pop [ /CIEBasedABC currentdict end ]
  488.   }
  489.   /CalCMYK {
  490.     pop /DeviceCMYK        % not defined by Adobe
  491.   }
  492.   /Lab {
  493.     1 oget 6 dict begin
  494.     dup /Range knownoget not { [-100 100 -100 100] } if
  495.     [0 100 null null null null] dup 2 4 -1 roll putinterval
  496.     /RangeABC exch def
  497.     //cslabinit { def } forall
  498.     dup /BlackPoint knownoget { /BlackPoint exch def } if
  499.     dup /WhitePoint knownoget { /WhitePoint exch def } if
  500.     pop [ /CIEBasedABC currentdict end ]
  501.   }
  502.   /ICCBased {
  503.     PDFfile fileposition exch
  504.     dup dup 1 oget
  505.     mark exch { oforce } forall .dicttomark
  506.     dup dup true resolvestream
  507.     /ReusableStreamDecode filter /DataSource exch put
  508.     1 exch put
  509.     exch PDFfile exch setfileposition
  510.   } bind
  511.   /Separation {
  512.     aload pop exch oforce resolvecolorspace exch oforce resolvefnproc
  513.     4 array astore
  514.   }
  515.   /DeviceN {
  516.     0 4 getinterval                    % ignore attributes
  517.     aload pop 3 -1 roll oforce
  518.     3 -1 roll oforce resolvecolorspace
  519.     3 -1 roll oforce resolvefnproc
  520.     4 array astore
  521.   }
  522.   /Indexed {
  523.     aload pop 3 -1 roll oforce resolvecolorspace
  524.         % If the underlying space is a Lab space, we must scale
  525.         % the output of the lookup table as part of DecodeABC.
  526.     dup dup type /arraytype eq { 0 get } if /CIEBasedABC eq {
  527.       dup 1 get /DecodeLMN known {
  528.     1 get dup length dict copy
  529.     begin /DecodeABC [ 0 2 4 {
  530.       RangeABC 1 index 1 add get RangeABC 2 index get sub /mul load
  531.       RangeABC 3 index get /add load
  532.       DecodeABC 6 -1 roll 2 idiv get [ 6 1 roll aload pop ] cvx
  533.     } for ] def
  534.     /RangeABC //01_3 def
  535.     currentdict end /CIEBasedABC exch 2 array astore
  536.       } if
  537.     } if
  538.     3 1 roll
  539.     oforce dup type /stringtype ne {
  540.         % The color lookup table is a stream.
  541.         % Get its contents.  Don't lose our place in PDFfile.
  542.         % Stack: /Indexed basespace hival lookup
  543.     PDFfile fileposition 5 1 roll true resolvestream
  544.         % Stack: filepos /Indexed basespace hival lookupstream
  545.     1 index 1 add
  546.         % Stack: filepos /Indexed basespace hival lookupstream len
  547.     3 index
  548.       dup dup type /arraytype eq { 0 get } if
  549.       //csncompdict exch get exec mul
  550.     string readstring pop
  551.         % Stack: filepos /Indexed basespace hival table
  552.     5 -1 roll PDFfile exch setfileposition
  553.     }
  554.     if 4 array astore
  555.   }
  556.   /Pattern {
  557.     dup type /nametype ne {
  558.       dup length 1 gt {
  559.     1 oget resolvecolorspace
  560.     /Pattern exch 2 array astore
  561.       } if
  562.     } if
  563.   }
  564. .dicttomark readonly def
  565.  
  566. /cssubst {        % <csname> cssubst <cspace'> true
  567.             % <csname> cssubst false
  568.   dup resolvecolorspace
  569.   dup 1 index ne { exch pop true } { pop pop false } ifelse
  570. } bdef
  571.  
  572. /csnames mark
  573.   /DeviceGray dup  /DeviceRGB dup  /DeviceCMYK dup  /Pattern dup
  574. .dicttomark readonly def
  575. /csresolve {        % <csresourcename> csresolve <cspace>
  576.   dup Page /ColorSpace rget {
  577.     exch pop resolvecolorspace
  578.   } {
  579.     //csnames 1 index known not { /undefined cvx signalerror } if
  580.   } ifelse
  581. } bdef
  582. /resolvecolorspace {    % <cspace> resolvecolorspace <cspace'>
  583.   dup dup type /arraytype eq { 0 get } if
  584.   //csrdict exch .knownget {
  585.     exec dup type /nametype ne { dup length 1 eq { 0 get } if } if
  586.   } {
  587.     csresolve
  588.   } ifelse
  589. } bdef
  590.  
  591. /scresolve {    % <c0> ... scresolve <multi>
  592.         % We can't really make sc[n] and SC[N] work, because
  593.         % the color space information isn't available at
  594.         % conversion time; so we hack it by assuming that
  595.         % all the operands on the stack are used, and that
  596.         % if the top operand is a name, it's a Pattern resource.
  597.   dup type /nametype eq
  598.     { Page /Pattern rget { resolvepattern } { null } ifelse }
  599.   if
  600.   dup type /dicttype eq {
  601.         % Check the PaintType, if any (shading patterns don't
  602.         % have one).
  603.     dup /PaintType .knownget { 2 eq } { false } ifelse
  604.   } {
  605.     .pdfcount 1 gt
  606.   } ifelse
  607. } bdef
  608.  
  609. /.pdfpaintproc {         % <patdict> <resdict> .pdfpaintproc -
  610.   DEBUG { (%Begin PaintProc) = flush } if
  611.     % For uncolored patterns, we have to unbind the current
  612.     % color and color space before running the PaintProc.
  613.     % There's no harm in doing this for colored patterns,
  614.     % so for simplicity, we always do it.
  615.   PDFfile fileposition 3 1 roll
  616.   q
  617.   null sc1 null SC1
  618.   exch false resolvestream pdfopdict .pdfruncontext
  619.   Q
  620.   DEBUG { (%End PaintProc) = flush } if
  621.   PDFfile exch setfileposition
  622. } bdef
  623.  
  624. /resolvepattern {    % <patternstreamdict> resolvepattern <patterndict>
  625.         % Don't do the resolvestream now: just capture the data
  626.         % from the file if necessary.
  627.   dup length dict copy
  628.   dup /FilePosition .knownget {
  629.     1 index /File get dup fileposition 3 1 roll
  630.         % Stack: dict savepos pos file
  631.     dup 3 -1 roll setfileposition
  632.     dup 3 index /Length oget string readstring pop
  633.         % Stack: dict savepos file string
  634.     3 1 roll exch setfileposition
  635.     1 index /File 3 -1 roll put
  636.     dup /FilePosition undef
  637.   } if
  638.   dup /Shading knownoget {
  639.     resolveshading 1 index /Shading 3 -1 roll put
  640.   } if
  641.   dup /PaintProc [
  642.         % Bind the resource dictionary into the PaintProc.
  643.     2 index /Resources knownoget { oforce } { 0 dict } ifelse
  644.     /.pdfpaintproc cvx
  645.   ] cvx put
  646.   DEBUG {
  647.     (%Pattern: ) print dup === flush
  648.   } if
  649. } bdef
  650.  
  651. drawopdict begin
  652.   /g { /DeviceGray cssubst { cs sc1 } { g } ifelse } bdef
  653.   /rg { /DeviceRGB cssubst { cs sc* } { rg } ifelse } bdef
  654.   /k { k } bdef
  655.   /cs { csresolve cs } bdef
  656.   /sc { scresolve { sc* } { sc1 } ifelse } bdef
  657.   /scn /sc load def
  658.   /G { /DeviceGray cssubst { CS SC1 } { G } ifelse } bdef
  659.   /RG { /DeviceRGB cssubst { CS SC* } { RG } ifelse } bdef
  660.   /K { K } bdef
  661.   /CS { csresolve CS } bdef
  662.   /ri { ri } bdef
  663.   /SC { scresolve { SC* } { SC1 } ifelse } bdef
  664.   /SCN /SC load def
  665. end
  666.  
  667. % ---------------- Paths ---------------- %
  668.  
  669. drawopdict begin
  670.             % Path construction
  671.   /m /moveto load def
  672.   /l /lineto load def
  673.   /c /curveto load def
  674.   /v { currentpoint 6 2 roll curveto } def
  675.   /y { 2 copy curveto } def
  676.   /re {
  677.    4 2 roll moveto  exch dup 0 rlineto  0 3 -1 roll rlineto  neg 0 rlineto
  678.    closepath
  679.   } def
  680.   /h /closepath load def
  681.             % Path painting and clipping
  682.   /n { n } def
  683.   /S { S } def
  684.   /s { s } def
  685.   /f { f } def
  686.   /f* { f* } def
  687.   /B { B } def
  688.   /b { b } def
  689.   /B* { B* } def
  690.   /b* { b* } def
  691.   /W { W } def
  692.   /W* { W* } def
  693.   /sh { resolvesh shfill } def
  694. end
  695.  
  696. % ---------------- XObjects ---------------- %
  697.  
  698. /xobjectprocs mark        % <dict> -proc- -
  699.   /Image { DoImage }
  700.   /Form { DoForm }
  701.   /PS { DoPS }
  702. .dicttomark readonly def
  703.  
  704. % Note that the keys in defaultdecodedict are resolved (PostScript, not PDF)
  705. % color space names.
  706. /defaultdecodedict mark
  707.   /DeviceGray { pop //01_1 } bind
  708.   /DeviceRGB { pop //01_3 } bind
  709.   /DeviceCMYK { pop //01_4 } bind
  710.   /CIEBasedA { 1 get /RangeA .knownget not { //01_1 } if } bind
  711.   /CIEBasedABC { 1 get /RangeABC .knownget not { //01_3 } if } bind
  712.   /ICCBased {
  713.      1 oget dup /Range .knownget {
  714.        exch pop
  715.      }{
  716.        /N get [ exch {0 1} repeat ] readonly
  717.      } ifelse
  718.   } bind
  719.   /Separation { pop //01_1 } bind
  720.   /DeviceN {
  721.     1 oget length [ exch {0 1} repeat ] readonly
  722.   } bind
  723.   /Indexed {
  724.     pop [ 0 1 BitsPerComponent bitshift 1 sub ]
  725.   } bind
  726. .dicttomark readonly def
  727.  
  728. /checkaltimage {    % <resdict> checkaltimage <resdict[']>
  729.   Printed {
  730.     dup /Alternates knownoget {
  731.       {
  732.     dup /DefaultForPrinting knownoget {
  733.       {
  734.         /Image oget exch pop exit
  735.       } {
  736.         pop
  737.       } ifelse
  738.     } {
  739.       pop
  740.     } ifelse
  741.       } forall
  742.     } if
  743.   } if
  744. } bdef
  745.  
  746. /makeimagedict {    % <resdict> <newdict> makeimagedict <imagemask>
  747.             % On return, newdict' is currentdict
  748.   begin
  749.   /Width 2 copy oget def
  750.   /Height 2 copy oget def
  751.   /BitsPerComponent 2 copy oget def
  752.   /Interpolate 2 copy knownoget { def } { pop } ifelse
  753.   makeimagekeys
  754. } bdef
  755. /makeimagekeys {    % <resdict> makeimagekeys <imagemask>
  756.         % newdict is currentdict
  757.         % Assumes Width, Height, BPC, Interpolate already copied.
  758.   /ImageType 1 def
  759.   /ImageMatrix Width 0 0
  760.         % Handle 0-height images specially.
  761.     Height dup 0 eq { pop 1 } if neg 0 1 index neg
  762.     6 array astore def
  763.   dup /ImageMask knownoget dup { and } if {
  764.         % Image mask
  765.         % Decode is required for the PostScript image operators.
  766.                 % AI8 writes bogus decode array [0 1 0 0 0 0 0 0]
  767.     /Decode 2 copy knownoget { 0 2 getinterval } { //01_1 } ifelse def
  768.         % BitsPerComponent may be missing for masks.
  769.         % The spec requires it, but some producers omit it, and
  770.         % Acrobat Reader doesn't care.
  771.     /BitsPerComponent 2 copy known { pop } { 1 def } ifelse
  772.     true
  773.   } {
  774.         % Opaque image
  775.     dup /ColorSpace oget resolvecolorspace /ColorSpace exch def
  776.         % Decode is required for the PostScript image operators.
  777.     /Decode 2 copy knownoget not {
  778.       ColorSpace //defaultdecodedict
  779.       ColorSpace dup type /arraytype eq { 0 get } if get exec
  780.     } if def
  781.     false
  782.   } ifelse
  783.         % Even though we're going to read data,
  784.         % pass false to resolvestream so that
  785.         % it doesn't try to use Length (which may not be present).
  786.   exch false resolvestream /DataSource exch def
  787. } bdef
  788.  
  789. /DoImage {
  790.   checkaltimage dup length 6 add dict
  791.   1 index /SMask knownoget { 1 index exch /SMask exch put } if
  792.   1 index /Mask knownoget { 1 index exch /Mask exch put } if
  793.   makeimagedict doimage
  794. } bdef
  795. /makemaskimage {    % <datasource> <imagemask> <Mask> makemaskimage
  796.             %   <datasource> <imagemask>, updates currentdict =
  797.             %   imagedict
  798.   dup type /arraytype eq {
  799.     /ImageType 4 def
  800.     /MaskColor exch def
  801.   } {
  802.         % Mask is a stream, another Image XObject.
  803.         % Stack: datasource imagemask(false) maskstreamdict
  804.     PDFfile fileposition exch
  805.     dup length dict makeimagedict pop
  806.         % In order to prevent the two data sources from being
  807.         % aliased, we need to make at least one a reusable stream.
  808.         % We pick the mask, since it's smaller (in case we need to
  809.         % read all its data now).
  810.         % Stack: datasource imagemask(false) savedpos
  811.         % maskdict is currentdict
  812.     /DataSource DataSource mark
  813.       /Intent 1
  814.       /AsyncRead true
  815.     .dicttomark .reusablestreamdecode def
  816.     PDFfile exch setfileposition
  817.     currentdict end currentdict end
  818.     5 dict begin
  819.     /ImageType 3 def
  820.     /InterleaveType 3 def
  821.     /DataDict exch def
  822.     /MaskDict exch def
  823.     /ColorSpace DataDict /ColorSpace get def
  824.   } ifelse
  825. } bdef
  826. /doimage {    % <imagemask> doimage -
  827.         % imagedict is currentdict, gets popped from dstack
  828.   DataSource exch
  829.   PDFversion 1.4 ge { currentdict /SMask knownoget } { false } ifelse {
  830.     makesoftmaskimage
  831.   } {
  832.     currentdict /Mask knownoget {
  833.       makemaskimage
  834.     } if
  835.   } ifelse
  836.         % Stack: datasource imagemask
  837.    % image and imagemask can be redefined in gs_init.ps to tweak interpolation
  838.    % after device-specific files are run. Don't bind them here.
  839.    { currentdict end setfillstate /imagemask }
  840.    { ColorSpace setcolorspace currentdict end setfillblend /image }
  841.   ifelse
  842.   .systemvar exec
  843.    
  844.         % Close the input stream, unless it is PDFfile or
  845.         % PDFsource.
  846.   dup dup PDFfile eq exch PDFsource eq or { pop } { closefile } ifelse
  847. } bdef
  848.  
  849. /.paintform {    % <formdict> <resdict> <stream> .paintform -
  850.   3 -1 roll dup /Group known {
  851.     .paintgroupform
  852.   } {
  853.     pop pdfopdict .pdfruncontext
  854.   } ifelse
  855. } bdef
  856.  
  857. /DoForm {
  858.     % Adobe 2nd edition of the PDF 1.3 spec makes /FormType
  859.     % and /Matrix keys optional. Cope with the missing keys.
  860.   dup length
  861.   1 index /Matrix known
  862.     { dict
  863.     }
  864.     { 1 add dict
  865.       dup /Matrix { 1 0 0 1 0 0 } cvlit put
  866.     }
  867.   ifelse
  868.   copy
  869.   dup /FormType known not {
  870.     dup length 1 add dict copy dup /FormType 1 put
  871.   } if
  872.  
  873.   dup [ 2 index /Resources knownoget { oforce } { 0 dict } ifelse
  874.   3 index false /resolvestream cvx
  875.   /.paintform cvx
  876.   ] cvx /PaintProc exch put
  877.   execform
  878. } bdef
  879.  
  880. /DoPS {
  881.   true resolvestream cvx exec
  882. } bdef
  883.  
  884. drawopdict begin
  885.   /Do {
  886.     setfillblend
  887.     PDFfile fileposition exch
  888.     dup Page /XObject rget { 
  889.       exch pop dup /Subtype get xobjectprocs exch get
  890.         % Don't leave extra objects on the stack while executing
  891.         % the definition of the form.
  892.       3 -1 roll 2 .execn
  893.     } {
  894.         % This should cause an error, but Acrobat Reader can
  895.         % continue, so we do too.
  896.       (%stderr) (w) file
  897.       dup (****************Undefined XObject resource: ) writestring 
  898.       dup 3 -1 roll write===
  899.       flushfile
  900.     } ifelse
  901.     PDFfile exch setfileposition
  902.   } bdef
  903. end
  904.  
  905. % ---------------- In-line images ---------------- %
  906.  
  907. % Undo the abbreviations in an in-line image dictionary.
  908. % Note that we must look inside array values.
  909. % /I is context-dependent.
  910. /unabbrevkeydict mark
  911.   /BPC /BitsPerComponent  /CS /ColorSpace  /D /Decode  /DP /DecodeParms
  912.   /F /Filter  /H /Height  /I /Interpolate  /IM /ImageMask  /W /Width
  913. .dicttomark readonly def
  914. /unabbrevvaluedict mark
  915.   /AHx /ASCIIHexDecode  /A85 /ASCII85Decode  /CC /CalCMYK
  916.   /CCF /CCITTFaxDecode  /CG /CalGray  /CR /CalRGB
  917.   /DCT /DCTDecode  /CMYK /DeviceCMYK  /Fl /FlateDecode
  918.   /G /DeviceGray  /RGB /DeviceRGB
  919.   /I /Indexed  /LZW /LZWDecode  /RL /RunLengthDecode
  920. .dicttomark readonly def
  921. /unabbrevtypedict mark
  922.   /nametype {
  923.     //unabbrevvaluedict 1 index .knownget { exch pop } if
  924.   }
  925.   /arraytype {
  926.     dup 0 1 2 index length 1 sub {
  927.       2 copy get unabbrevvalue put dup
  928.     } for pop
  929.   }
  930. .dicttomark readonly def
  931. /unabbrevvalue {    % <obj> unabbrevvalue <obj'>
  932.   oforce //unabbrevtypedict 1 index type .knownget { exec } if
  933. } bdef
  934.  
  935. drawopdict begin
  936.   /BI { mark } bdef
  937.   /ID {
  938.     counttomark 2 idiv dup 6 add dict begin {
  939.       exch //unabbrevkeydict 1 index .knownget { exch pop } if
  940.       exch unabbrevvalue def
  941.     } repeat pop
  942.     /File PDFsource def
  943.     currentdict makeimagekeys doimage    
  944.     % The Adobe documentation says that the data following ID
  945.     % consists of "lines", and some PDF files (specifically, some files
  946.     % produced by PCL2PDF from Visual Software) contain garbage bytes
  947.     % between the last byte of valid data and an EOL.
  948.         % Some files (PDFOUT v3.8d by GenText) have EI immediately following
  949.         % the stream. Some have no EOL and garbage bytes.
  950.         % Therefore, we skip all bytes before EI or EOL 
  951.     0
  952.       { PDFsource read not { //true exit } if
  953.         dup 10 eq 1 index 13 eq or
  954.           { pop PDFsource token pop /EI ne exit
  955.           }
  956.         if
  957.         exch 69 eq 1 index 73 eq and { //false exit } if  % 'EI'
  958.       }
  959.     loop
  960.     exch pop
  961.       { /ID cvx /syntaxerror signalerror
  962.       }
  963.     if
  964.   } bdef
  965. end
  966.  
  967. % ================================ Text ================================ %
  968.  
  969. drawopdict begin
  970.             % Text control
  971.   /BT { BT } def
  972.   /ET { ET } def
  973.   /Tc { Tc } def
  974.   /TL { TL } def
  975.   /Tr { Tr } def
  976.   /Ts { Ts } def
  977.   /Tw { Tw } def
  978.   /Tz { Tz } def
  979.             % Text positioning
  980.   /Td { Td } def
  981.   /TD { TD } def
  982.   /Tm { Tm } def
  983.   /T* { T* } def
  984.             % Text painting
  985.   /Tj { Tj } def
  986.   /' { ' } def
  987.   /" { " } def
  988.   /TJ { TJ } def
  989. end
  990.  
  991. % ============================== Annotations ============================== %
  992.  
  993.  
  994.  
  995. % Get and normalize an annotation's rectangle.
  996. /annotrect {        % <annot> annotrect <x> <y> <w> <h>
  997.   /Rect get aload pop
  998.   exch 3 index sub dup 0 lt { dup 5 -1 roll add 4 1 roll neg } if
  999.   exch 2 index sub dup 0 lt { dup 4 -1 roll add 3 1 roll neg } if
  1000. } bdef
  1001.  
  1002. % Set an annotation color.
  1003. /annotsetcolor {    % <annot> annotsetcolor -
  1004.   /C knownoget { aload pop setrgbcolor } { 0 setgray } ifelse
  1005. } bdef
  1006.  
  1007. % Draw the border.  Currently, we ignore requests for beveling, and we
  1008. % don't round the corners of rectangles.
  1009. /strokeborder {        % <annot> <width> <dash> strokeborder -
  1010.   1 index 0 ne {    % do not draw if border width is 0
  1011.     gsave
  1012.     2 index annotsetcolor
  1013.     0 setdash dup setlinewidth
  1014.     exch annotrect
  1015.     2 { 4 index sub 4 1 roll } repeat
  1016.     2 { 4 index 0.5 mul add 4 1 roll } repeat
  1017.     rectstroke pop
  1018.     grestore
  1019.   } {
  1020.     pop pop pop
  1021.   } ifelse
  1022. } bdef
  1023.  
  1024. % Draw an annotation border.
  1025. /drawborder {        % <annot> drawborder -
  1026.   gsave
  1027.   dup /BS knownoget {
  1028.     dup /W knownoget not { 1 } if
  1029.     [] 2 index /S knownoget {
  1030.       /D eq { 2 index /D knownoget not { [3] } if exch pop } if
  1031.     } if 3 -1 roll pop strokeborder
  1032.   } {
  1033.     dup /Border knownoget {
  1034.       dup 2 get
  1035.       exch dup length 3 gt { 3 get } { pop [] } ifelse
  1036.       strokeborder
  1037.     } {
  1038.       pop
  1039.     } ifelse
  1040.   } ifelse
  1041.   grestore
  1042. } bdef
  1043.  
  1044. %
  1045. %   The PDF annotation F (flags) integer is bit encoded.
  1046. %   Bit 1 (LSB) Invisible:  1 --> Do not display if no handler.
  1047. %         Note:  We have no handlers but we ignore this bit.
  1048. %   Bit 2 Hidden:  1 --> Do not display.  We will not display if this bit is set.
  1049. %   Bit 3 Print:  1 --> Display if printing.  We will display if this bit set
  1050. %         (and not hidden) and Printed is true
  1051. %   Bit 4 NoZoom:  1 --> Do not zoom annotation even if image is zoomed.
  1052. %   Bit 5 NoRotate:  1 --> Do not rotate annotation even if image is rotated.
  1053. %   Bit 6 NoView:  0 --> Display if this is a 'viewer'.  We will display
  1054. %         if this bit is not set (and not hidden) and Printed is false
  1055. %   Bit 7 Read Only - 1 --> No interaction.  We ignore this bit
  1056. %
  1057. /annotvisible {            % <annot> annotvisible <visible>
  1058.   /F knownoget not { 0 } if         % Get flag value
  1059.   dup 2 and 0 eq              % Check hidden flag
  1060.   exch dup 4 and 0 ne Printed and    % Check print flag
  1061.   exch 64 and 0 eq Printed not and    % Check noview flag
  1062.   or                    % Combine print and view
  1063.   and                     % Combine with 'hidden' flag test
  1064. } bdef
  1065.  
  1066. /drawwidget {            % <scalefactor> <annot> drawwidget -
  1067.   dup /AP knownoget {
  1068.     % Always use the Normal appearance.
  1069.     /N oget
  1070.         % Acrobat Distiller produces files in which this Form
  1071.         % XObject lacks Type and Subtype keys.  This is illegal,
  1072.         % but Acrobat Reader accepts it.  The only way we can
  1073.         % tell whether this is a Form or a set of sub-appearances
  1074.         % is by testing for the stream Length key.
  1075.     dup /Length known {
  1076.               % If this is a form then simply use it
  1077.       true
  1078.     } {
  1079.       1 index /AS knownoget not {
  1080.               % If we do not have AS then use any appearance
  1081.     { exch pop oforce exit } forall true
  1082.       } { 
  1083.         % Stack: annot Ndict AS
  1084.         % Get the specified appearance.  If no appearance, then
  1085.         % display nothing - set stack = false.
  1086.     knownoget
  1087.       } ifelse
  1088.     } ifelse
  1089.  
  1090.         % Stack: scale annot appearance true
  1091.         % Stack: scale annot false
  1092.     {
  1093.               % Draw appearance
  1094.       1 index annotrect pop pop translate
  1095.       2 index dup scale        % Apply scale factor
  1096.       DoForm
  1097.     } if
  1098.   } if pop pop
  1099. } bdef
  1100.  
  1101. %
  1102. %  For stamp object we have to determine the size of the output rectangle
  1103. %  and the size of the BBox for the stamp image.  From these we calculate
  1104. %  a scale factor for drawing the stamp.
  1105. %
  1106. /calcstampscale {        % <annot> calcstampscale scale
  1107.   dup annotrect 4 -2 roll pop pop pop    % get x width
  1108.   dup 0 lt { neg } if        % get magnitude
  1109.   exch /AP knownoget {
  1110.     /N knownoget {
  1111.       /BBox knownoget {
  1112.          aload pop 4 -2 roll pop pop pop
  1113.          div
  1114.       } {
  1115.         pop 1            % default to unity scaling
  1116.       } ifelse            % if we have /BBox
  1117.     } {
  1118.       pop 1
  1119.     } ifelse            % if we have /N
  1120.   } {
  1121.     pop 1
  1122.   } ifelse            % if we have /AP
  1123. } bdef
  1124.  
  1125. /drawlink {            % <annot> drawlink -
  1126.   dup drawborder
  1127.   1 exch drawwidget
  1128. } bdef
  1129.  
  1130. % Draw an annotation.
  1131. /drawannottypes mark
  1132.   /Link { drawlink } bind
  1133.   /Stamp { dup calcstampscale exch drawwidget } bind
  1134. .dicttomark readonly def
  1135. /drawannot {        % <annot> drawannot -
  1136.   dup annotvisible {
  1137.     gsave
  1138.     dup dup /Subtype get //drawannottypes exch .knownget {
  1139.       exec
  1140.     } {
  1141.       1 exch drawwidget        % Use drawwidget for everything else
  1142.     } ifelse            % type known
  1143.     grestore
  1144.   } if pop            % annotvisible
  1145. } bdef
  1146. currentdict /drawannottypes undef
  1147.  
  1148. end            % pdfdict
  1149. end            % GS_PDF_ProcSet
  1150. .setglobal
  1151.